﻿package mortal.game.utils
{
    import Message.BroadCast.*;
    import Message.Public.*;
    import extend.language.*;
    import mortal.game.*;
    import mortal.game.cache.*;
    import mortal.game.manager.*;
    import mortal.game.scene3D.layer3D.utils.*;
    import mortal.game.scene3D.map3D.util.*;
    import mortal.game.scene3D.player.entity.*;
    import mortal.game.scene3D.player.info.*;

    public class EntityRelationUtil extends Object
    {
        public static const FIREND:int = 1;
        public static const ENEMY:int = 2;
        public static const NEUTRAL:int = 3;

        public function EntityRelationUtil()
        {
            return;
        }// end function

        public static function isSelfPetByEntityId(param1:SEntityId, param2:SEntityId = null) : Boolean
        {
            if (param2 == null)
            {
                param2 = Cache.instance.role.roleEntityInfo.entityInfo.entityId;
            }
            if (param1.type == EEntityType._EEntityTypePet)
            {
                if (param1.id == param2.id && param1.typeEx == param2.typeEx && param1.typeEx2 == param2.typeEx2)
                {
                    return true;
                }
            }
            return false;
        }// end function

        public static function isSelfCarByEntityId(param1:SEntityInfo, param2:SEntityId = null) : Boolean
        {
            if (param2 == null)
            {
                param2 = Cache.instance.role.roleEntityInfo.entityInfo.entityId;
            }
            if (isCar(param1.entityId) && isOwnerSelf(param1, param2))
            {
                return true;
            }
            return false;
        }// end function

        public static function isCar(param1:SEntityId) : Boolean
        {
            return param1 && param1.type == EEntityType._EEntityTypeEscort;
        }// end function

        public static function isOwnerSelf(param1:SEntityInfo, param2:SEntityId = null) : Boolean
        {
            if (!param2)
            {
                param2 = Cache.instance.role.roleEntityInfo.entityInfo.entityId;
            }
            var _loc_3:* = getSummonMaster(param1).entityId;
            return EntityUtil.equal(param2, _loc_3);
        }// end function

        public static function isOwnerSelfByShortMapEntity(param1:SShortMapEntity, param2:SEntityId = null) : Boolean
        {
            if (!param2)
            {
                param2 = Cache.instance.role.roleEntityInfo.entityInfo.entityId;
            }
            var _loc_3:* = param1.entityId;
            if (param1.ownerEntityId && param1.ownerEntityId.id != 0)
            {
                _loc_3 = param1.ownerEntityId;
            }
            return EntityUtil.equal(param2, _loc_3);
        }// end function

        public static function getSummonMaster(param1:SEntityInfo) : SEntityInfo
        {
            var _loc_2:EntityInfo = null;
            if (param1.ownerEntityId && param1.ownerEntityId.id)
            {
                if (param1.ownerEntityId.type == EEntityType._EEntityTypePlayer)
                {
                    _loc_2 = Cache.instance.entity.getEntityInfoById(param1.ownerEntityId);
                    if (_loc_2)
                    {
                        return _loc_2.entityInfo;
                    }
                }
                else if (param1.entityId.type == EEntityType._EEntityTypeMercenary)
                {
                    _loc_2 = Cache.instance.entity.getEntityInfoById(param1.ownerEntityId);
                    if (_loc_2)
                    {
                        return getSummonMaster(_loc_2.entityInfo);
                    }
                }
            }
            return param1;
        }// end function

        public static function getSummonMasterEntityInfo(param1:SEntityInfo) : EntityInfo
        {
            var _loc_2:EntityInfo = null;
            if (param1.ownerEntityId && param1.ownerEntityId.id)
            {
                if (param1.ownerEntityId.type == EEntityType._EEntityTypePlayer)
                {
                    _loc_2 = Cache.instance.entity.getEntityInfoById(param1.ownerEntityId);
                    if (_loc_2)
                    {
                        if (_loc_2.entityInfo)
                        {
                            return _loc_2;
                        }
                    }
                }
                else if (param1.entityId.type == EEntityType._EEntityTypeMercenary)
                {
                    _loc_2 = Cache.instance.entity.getEntityInfoById(param1.ownerEntityId);
                    if (_loc_2)
                    {
                        if (_loc_2.entityInfo)
                        {
                            if (_loc_2.entityInfo.ownerEntityId)
                            {
                                return getSummonMasterEntityInfo(_loc_2.entityInfo);
                            }
                            return _loc_2;
                        }
                    }
                }
            }
            return null;
        }// end function

        public static function isSummonMasterPlayer(param1:SpritePlayer) : Boolean
        {
            if (param1.entityInfo && param1.entityInfo.entityInfo)
            {
                return param1.entityInfo.entityInfo.ownerEntityId.type == EEntityType._EEntityTypePlayer;
            }
            return false;
        }// end function

        public static function isFriend(param1:SEntityInfo, param2:Boolean = false) : Boolean
        {
            param1 = getSummonMaster(param1);
            var _loc_3:* = param1.entityId.type == EEntityType._EEntityTypePlayer;
            var _loc_4:* = Cache.instance.role.entityInfo;
            if (EntityUtil.equal(param1.entityId, _loc_4.entityId))
            {
                return true;
            }
            if (_loc_3)
            {
                if (_loc_4.fightMode == EEntityFightMode._EEntityFightModeBattle)
                {
                    if (param1.fightMode == EEntityFightMode._EEntityFightModeBattle && EntityUtil.equal(Cache.instance.publicCache.battleEnemy, param1.entityId))
                    {
                        return false;
                    }
                    return true;
                }
                else if (param1.fightMode == EEntityFightMode._EEntityFightModeBattle)
                {
                    return true;
                }
            }
            if (_loc_3 && _loc_4.fightMode == EEntityFightMode._EEntityFightModePeace && param1.fightMode == EEntityFightMode._EEntityFightModePeace)
            {
                return true;
            }
            var _loc_5:* = isMapfightModeFriend(param1, param2);
            if (_loc_5)
            {
                return true;
            }
            if (_loc_3 && isMapSafeArea(param1))
            {
                return true;
            }
            return false;
        }// end function

        public static function isFriendly(param1:SEntityInfo) : Boolean
        {
            param1 = getSummonMaster(param1);
            return isMapfightModeFriend(param1, false);
        }// end function

        public static function isMapfightModeFriend(param1:SEntityInfo, param2:Boolean) : Boolean
        {
            var _loc_3:* = Game.sceneInfo.sMapDefine.fightMode;
            var _loc_4:* = Cache.instance.role.entityInfo;
            var _loc_5:* = EntityUtil.isSameServer(param1.entityId, _loc_4.entityId);
            if (EntityUtil.equal(_loc_4.entityId, param1.entityId))
            {
                return true;
            }
            if (param1.entityId.type != EEntityType._EEntityTypePlayer && !isCar(param1.entityId))
            {
                _loc_3 = EFightMode._EFightModeForce;
            }
            if (_loc_3 == EFightMode._EFightModePeace)
            {
                if (param1.entityId.type == EEntityType._EEntityTypePlayer)
                {
                    return true;
                }
            }
            if (_loc_3 & EFightMode._EFightModeServer)
            {
                if (_loc_5)
                {
                    if (param2)
                    {
                        MsgManager.showRollTipsMsg(Language.getString(11028));
                    }
                    return true;
                }
            }
            if (_loc_3 & EFightMode._EFightModeTeam)
            {
                if (isInRoleGroup(param1))
                {
                    if (param2)
                    {
                        MsgManager.showRollTipsMsg(Language.getString(11029));
                    }
                    return true;
                }
            }
            if (_loc_3 & EFightMode._EFightModeGuild)
            {
                if (param1 && _loc_5 && EntityUtil.equal(param1.guildId, _loc_4.guildId) && _loc_4.guildId.id != 0)
                {
                    if (param2)
                    {
                        MsgManager.showRollTipsMsg(Language.getString(11027));
                    }
                    return true;
                }
            }
            if (_loc_3 & EFightMode._EFightModeCamp)
            {
                if (param1.camp == _loc_4.camp && _loc_5)
                {
                    if (param2)
                    {
                        MsgManager.showRollTipsMsg(Language.getString(11027));
                    }
                    return true;
                }
            }
            if (_loc_3 & EFightMode._EFightModeForce)
            {
                if (param1.force == EForce._EForceNeutral || param1.force == EForce._EForceDecorate)
                {
                    return true;
                }
                if (param1.force == EForce._EForceServer && EntityUtil.isSameServer(param1.entityId, _loc_4.entityId))
                {
                    if (param2)
                    {
                        MsgManager.showRollTipsMsg(Language.getString(11028));
                    }
                    return true;
                }
                else
                {
                    if (param1.force == EForce._EForceGuild && EntityUtil.equal(param1.guildId, _loc_4.guildId))
                    {
                        return true;
                    }
                    if (param1.force == _loc_4.force)
                    {
                        if (param2)
                        {
                            MsgManager.showRollTipsMsg(Language.getString(11028));
                        }
                        return true;
                    }
                }
            }
            if (_loc_3 & EFightMode._EFightModeFree)
            {
                return EntityUtil.equal(param1.entityId, _loc_4.entityId);
            }
            return false;
        }// end function

        public static function isMapSafeArea(param1:SEntityInfo) : Boolean
        {
            var _loc_2:Boolean = false;
            return GameMapUtil.isMapPeaceArea(param1.entityId, _loc_2) || GameMapUtil.isMapPeaceArea(Cache.instance.role.entityInfo.entityId, _loc_2);
        }// end function

        public static function isInRoleGroup(param1:SEntityInfo) : Boolean
        {
            if (Cache.instance.group.isInGroup)
            {
                return Cache.instance.group.entityIsInGroup(param1.entityId);
            }
            return false;
        }// end function

        public static function isMonsterPlayer(param1:SpritePlayer) : Boolean
        {
            var _loc_2:MonsterPlayer = null;
            if (param1 is MonsterPlayer)
            {
                _loc_2 = param1 as MonsterPlayer;
                if (_loc_2.bossInfo && _loc_2.bossInfo.category != EBossCategory._EBossCategoryRobot)
                {
                    return true;
                }
            }
            return false;
        }// end function

        public static function getMapFightMode() : int
        {
            var _loc_1:* = Game.sceneInfo.sMapDefine.fightMode;
            if (_loc_1 & EFightMode._EFightModeServer)
            {
                return EFightMode._EFightModeServer;
            }
            if (_loc_1 & EFightMode._EFightModeForce)
            {
                return EFightMode._EFightModeForce;
            }
            if (_loc_1 & EFightMode._EFightModeGuild)
            {
                return EFightMode._EFightModeGuild;
            }
            if (_loc_1 & EFightMode._EFightModeUnion)
            {
                return EFightMode._EFightModeUnion;
            }
            if (_loc_1 & EFightMode._EFightModeCamp)
            {
                return EFightMode._EFightModeCamp;
            }
            if (_loc_1 & EFightMode._EFightModeTeam)
            {
                return EFightMode._EFightModeTeam;
            }
            if (_loc_1 & EFightMode._EFightModeFree)
            {
                return EFightMode._EFightModeFree;
            }
            return EFightMode._EFightModeFree;
        }// end function

    }
}
